// 提示词模板管理服务
import axios from 'axios';

// API日志工具导入
import apiLogger from '@utils/apiLogger';

// 创建axios实例并集成日志
const api = axios.create({
  baseURL: process.env.REACT_APP_API_URL || 'http://localhost:6001',
  headers: {
    'Content-Type': 'application/json',
  },
});

// 集成API日志记录
apiLogger.createAxiosInterceptors(api);

// 模板类型枚举
export enum PromptTemplateType {
  Chat = 'chat',
  Completion = 'completion',
  Instruction = 'instruction',
  System = 'system',
  Code = 'code',
  Analysis = 'analysis',
  Creative = 'creative',
  Custom = 'custom'
}

// 参数类型枚举
export enum ParameterType {
  String = 'string',
  Number = 'number',
  Boolean = 'boolean',
  Array = 'array',
  Object = 'object'
}

// 参数接口
export interface PromptTemplateParameter {
  name: string;
  type: ParameterType;
  description: string;
  required: boolean;
  defaultValue?: any;
  options?: any[];
  validation?: {
    min?: number;
    max?: number;
    pattern?: string;
    enum?: any[];
  };
}

// 模板DTO接口
export interface PromptTemplateDto {
  id: string;
  name: string;
  description: string;
  content: string;
  templateType: PromptTemplateType;
  category: string;
  tags: string[];
  version: number;
  isSystem: boolean;
  isActive: boolean;
  parameters: Record<string, PromptTemplateParameter>;
  author: string;
  createdAt: string;
  updatedAt?: string;
}

// 模板详情DTO接口
export interface PromptTemplateDetailDto extends PromptTemplateDto {
  parentTemplateId?: string;
  documentationUrl?: string;
  examples: string[];
}

// 查询参数接口
export interface GetPromptTemplateListInput {
  filter?: string;
  templateType?: PromptTemplateType;
  isActive?: boolean;
  category?: string;
  author?: string;
  skipCount: number;
  maxResultCount: number;
  sorting?: string;
}

// 创建模板输入接口
export interface CreatePromptTemplateInput {
  name: string;
  description: string;
  content: string;
  templateType: PromptTemplateType;
  category: string;
  tags: string[];
  parameters: Record<string, PromptTemplateParameter>;
}

// 更新模板输入接口
export interface UpdatePromptTemplateInput {
  name: string;
  description: string;
  content: string;
  templateType: PromptTemplateType;
  category: string;
  tags: string[];
  parameters: Record<string, PromptTemplateParameter>;
}

// 渲染模板输入接口
export interface RenderPromptTemplateInput {
  parameters: Record<string, any>;
}

// 渲染结果接口
export interface PromptTemplateRenderResultDto {
  success: boolean;
  renderedContent?: string;
  usedParameters?: Record<string, any>;
  missingParameters?: string[];
  error?: string;
  timestamp: string;
}

// 复制模板输入接口
export interface CopyPromptTemplateInput {
  newName?: string;
  newDescription?: string;
  newCategory?: string;
  newTags?: string[];
}

// 创建版本输入接口
export interface CreatePromptTemplateVersionInput {
  newContent: string;
  newVersion: number;
  description?: string;
}

// 统计信息接口
export interface PromptTemplateStatisticsDto {
  totalTemplates: number;
  activeTemplates: number;
  systemTemplates: number;
  userTemplates: number;
  typeDistribution: Record<PromptTemplateType, number>;
  categoryDistribution: Record<string, number>;
  timestamp: string;
}

// 获取模板列表
export async function getPromptTemplateList(params: GetPromptTemplateListInput): Promise<{
  items: PromptTemplateDto[];
  totalCount: number;
}> {
  const response = await axios.get('/api/app/prompt-template', {
    params
  });
  return {
    items: response.data.items || [],
    totalCount: response.data.totalCount || 0
  };
}

// 获取模板详情
export async function getPromptTemplateDetail(id: string): Promise<PromptTemplateDetailDto> {
  const response = await axios.get(`/api/app/prompt-template/${id}`);
  return response.data;
}

// 创建模板
export async function createPromptTemplate(input: CreatePromptTemplateInput): Promise<PromptTemplateDto> {
  const response = await axios.post('/api/app/prompt-template', input);
  return response.data;
}

// 更新模板
export async function updatePromptTemplate(id: string, input: UpdatePromptTemplateInput): Promise<PromptTemplateDto> {
  const response = await axios.put(`/api/app/prompt-template/${id}`, input);
  return response.data;
}

// 删除模板
export async function deletePromptTemplate(id: string): Promise<void> {
  await axios.delete(`/api/app/prompt-template/${id}`);
}

// 渲染模板
export async function renderPromptTemplate(id: string, input: RenderPromptTemplateInput): Promise<PromptTemplateRenderResultDto> {
  const response = await axios.post(`/api/app/prompt-template/${id}/render`, input);
  return response.data;
}

// 复制模板
export async function copyPromptTemplate(id: string, input: CopyPromptTemplateInput): Promise<PromptTemplateDto> {
  const response = await axios.post(`/api/app/prompt-template/${id}/copy`, input);
  return response.data;
}

// 获取分类列表
export async function getTemplateCategories(): Promise<string[]> {
  const response = await axios.get('/api/app/prompt-template/categories');
  return response.data || [];
}

// 获取统计信息
export async function getTemplateStatistics(): Promise<PromptTemplateStatisticsDto> {
  const response = await axios.get('/api/app/prompt-template/statistics');
  return response.data;
}

// 创建版本
export async function createTemplateVersion(id: string, input: CreatePromptTemplateVersionInput): Promise<PromptTemplateDto> {
  const response = await axios.post(`/api/app/prompt-template/${id}/versions`, input);
  return response.data;
}

// 模板类型显示映射
export const templateTypeMap = {
  [PromptTemplateType.Chat]: { text: '聊天', color: 'blue' },
  [PromptTemplateType.Completion]: { text: '补全', color: 'green' },
  [PromptTemplateType.Instruction]: { text: '指令', color: 'orange' },
  [PromptTemplateType.System]: { text: '系统', color: 'purple' },
  [PromptTemplateType.Code]: { text: '代码', color: 'cyan' },
  [PromptTemplateType.Analysis]: { text: '分析', color: 'red' },
  [PromptTemplateType.Creative]: { text: '创意', color: 'pink' },
  [PromptTemplateType.Custom]: { text: '自定义', color: 'default' }
};

// 参数类型显示映射
export const parameterTypeMap = {
  [ParameterType.String]: { text: '字符串', color: 'blue' },
  [ParameterType.Number]: { text: '数字', color: 'green' },
  [ParameterType.Boolean]: { text: '布尔', color: 'orange' },
  [ParameterType.Array]: { text: '数组', color: 'purple' },
  [ParameterType.Object]: { text: '对象', color: 'pink' }
};

// 预定义模板示例
export const sampleTemplates = [
  {
    name: '通用助手',
    description: '通用的AI助手模板',
    content: `你是一个智能助手，请根据用户的需求提供帮助。

用户需求：{{user_request}}

请提供详细的回答：`,
    templateType: PromptTemplateType.Chat,
    category: '通用',
    tags: ['助手', '通用', 'AI'],
    parameters: {
      user_request: {
        name: 'user_request',
        type: ParameterType.String,
        description: '用户的需求描述',
        required: true
      }
    }
  },
  {
    name: '代码审查',
    description: '代码审查模板',
    content: `请对以下代码进行审查：

编程语言：{{programming_language}}
代码内容：
\`\`\`{{programming_language}}
{{code_content}}
\`\`\`

请从以下几个方面进行审查：
1. 代码质量和可读性
2. 性能优化建议
3. 安全性问题
4. 最佳实践建议`,
    templateType: PromptTemplateType.Code,
    category: '开发',
    tags: ['代码', '审查', '质量'],
    parameters: {
      programming_language: {
        name: 'programming_language',
        type: ParameterType.String,
        description: '编程语言',
        required: true,
        options: ['javascript', 'python', 'java', 'csharp', 'cpp', 'go', 'rust']
      },
      code_content: {
        name: 'code_content',
        type: ParameterType.String,
        description: '需要审查的代码内容',
        required: true
      }
    }
  },
  {
    name: '数据分析',
    description: '数据分析报告模板',
    content: `请对以下数据进行分析：

数据描述：{{data_description}}
分析目标：{{analysis_goal}}
数据样本：{{data_sample}}

请提供详细的分析报告，包括：
1. 数据概况
2. 关键发现
3. 趋势分析
4. 结论和建议`,
    templateType: PromptTemplateType.Analysis,
    category: '数据',
    tags: ['分析', '数据', '报告'],
    parameters: {
      data_description: {
        name: 'data_description',
        type: ParameterType.String,
        description: '数据描述',
        required: true
      },
      analysis_goal: {
        name: 'analysis_goal',
        type: ParameterType.String,
        description: '分析目标',
        required: true
      },
      data_sample: {
        name: 'data_sample',
        type: ParameterType.String,
        description: '数据样本',
        required: false
      }
    }
  }
];

// 模板参数验证函数
export function validateTemplateParameters(
  template: PromptTemplateDto,
  parameters: Record<string, any>
): { valid: boolean; errors: string[] } {
  const errors: string[] = [];

  // 检查必需参数
  Object.entries(template.parameters).forEach(([key, param]) => {
    if (param.required && parameters[key] === undefined) {
      errors.push(`缺少必需参数: ${key}`);
    }
  });

  // 验证参数类型和值
  Object.entries(parameters).forEach(([key, value]) => {
    const param = template.parameters[key];
    if (!param) return;

    // 类型验证
    switch (param.type) {
      case ParameterType.Number:
        if (typeof value !== 'number' && isNaN(Number(value))) {
          errors.push(`参数 ${key} 必须是数字`);
        }
        break;
      case ParameterType.Boolean:
        if (typeof value !== 'boolean' && typeof value !== 'string') {
          errors.push(`参数 ${key} 必须是布尔值`);
        }
        break;
      case ParameterType.Array:
        if (!Array.isArray(value)) {
          errors.push(`参数 ${key} 必须是数组`);
        }
        break;
      case ParameterType.Object:
        if (typeof value !== 'object' || Array.isArray(value)) {
          errors.push(`参数 ${key} 必须是对象`);
        }
        break;
    }

    // 值验证
    if (param.validation) {
      const validation = param.validation;

      if (validation.min !== undefined && value < validation.min) {
        errors.push(`参数 ${key} 不能小于 ${validation.min}`);
      }

      if (validation.max !== undefined && value > validation.max) {
        errors.push(`参数 ${key} 不能大于 ${validation.max}`);
      }

      if (validation.pattern && typeof value === 'string') {
        const regex = new RegExp(validation.pattern);
        if (!regex.test(value)) {
          errors.push(`参数 ${key} 格式不正确`);
        }
      }

      if (validation.enum && !validation.enum.includes(value)) {
        errors.push(`参数 ${key} 必须是以下值之一: ${validation.enum.join(', ')}`);
      }
    }
  });

  return {
    valid: errors.length === 0,
    errors
  };
}

// 导出服务对象
const promptTemplateService = {
  // 枚举类型
  PromptTemplateType,
  ParameterType,

  // API函数
  getPromptTemplateList,
  getPromptTemplateDetail,
  createPromptTemplate,
  updatePromptTemplate,
  deletePromptTemplate,
  renderPromptTemplate,
  copyPromptTemplate,
  getTemplateCategories,
  getTemplateStatistics,
  createTemplateVersion,

  // 映射对象
  templateTypeMap,
  parameterTypeMap,

  // 示例数据
  sampleTemplates,

  // 验证函数
  validateTemplateParameters,

  // 别名方法
  getList: getPromptTemplateList,
  getDetail: getPromptTemplateDetail,
  create: createPromptTemplate,
  update: updatePromptTemplate,
  delete: deletePromptTemplate,
  render: renderPromptTemplate,
  copy: copyPromptTemplate,
  getCategories: getTemplateCategories,
  getStatistics: getTemplateStatistics,
  createVersion: createTemplateVersion
};

export default promptTemplateService;